home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / raytrace / rayshade / graphtal.lzh / Graphtal.Amiga / Interpreter.C < prev    next >
C/C++ Source or Header  |  1992-11-17  |  20KB  |  894 lines
  1. /*
  2.  * Interpreter.C - methods for turtle interpreter.
  3.  *
  4.  * Copyright (C) 1992, Christoph Streit (streit@iam.unibe.ch)
  5.  *                     University of Berne, Switzerland
  6.  * All rights reserved.
  7.  *
  8.  * This software may be freely copied, modified, and redistributed
  9.  * provided that this copyright notice is preserved on all copies.
  10.  *
  11.  * You may not distribute this software, in whole or in part, as part of
  12.  * any commercial product without the express consent of the authors.
  13.  *
  14.  * There is no warranty or other guarantee of fitness of this software
  15.  * for any purpose.  It is provided solely "as is".
  16.  *
  17.  */
  18.  
  19. #include "Interpreter.h"
  20. #include "Options.h"
  21. #include "Polygon.h"
  22. #include "Turtle.h"
  23. #include "DeviceDriver.h"
  24. #include "Module.h"
  25. #include "Hull.h"
  26. #include "boolean.h"
  27.  
  28. #define startBranchSymbol "["
  29. #define endBranchSymbol   "]"
  30.  
  31. #ifdef OLD_STYLE_CPP
  32.  InterpreterFunctions Interpreter::FuncTable[] = {
  33. #else
  34.  Interpreter::InterpreterFunctions Interpreter::FuncTable[] = {
  35. #endif
  36.  
  37.   {"F",               &Interpreter::forward},
  38.   {"wi",              &Interpreter::width},
  39.   {"G",               &Interpreter::go},
  40.   {"f",               &Interpreter::go},
  41.   {"pt",              &Interpreter::pitch},
  42.   {"&",               &Interpreter::pitch_negativ},
  43.   {"^",               &Interpreter::pitch},
  44.   {"ro",              &Interpreter::roll},
  45.   {"\\",              &Interpreter::roll_negativ},
  46.   {"/",               &Interpreter::roll},
  47.   {"tu",              &Interpreter::turn},
  48.   {"+",               &Interpreter::turn_negativ},
  49.   {"-",               &Interpreter::turn},
  50.   {"rv",              &Interpreter::rotate_vertical},
  51.   {"$",               &Interpreter::rotate_vertical},
  52.   {"|",               &Interpreter::reverse},
  53.   {startBranchSymbol, &Interpreter::push},
  54.   {endBranchSymbol,   &Interpreter::pop},
  55.   {"{",               &Interpreter::startPolygon},
  56.   {"sv",              &Interpreter::saveVertex},
  57.   {".",               &Interpreter::saveVertex},
  58.   {"}",               &Interpreter::endPolygon},
  59.   {"t",               &Interpreter::tropism},
  60.   {"we",              &Interpreter::weight},
  61.   {"co",              &Interpreter::color},
  62.   {"sm",              &Interpreter::beginMacro},
  63.   {"em",              &Interpreter::endMacro},
  64.   {"xm",              &Interpreter::executeMacro},
  65.   {"lib",             &Interpreter::libraryObject},
  66.   {"s",               &Interpreter::sphere},
  67.   {"tri",             &Interpreter::triangle},
  68.   {"poly",            &Interpreter::polygon},
  69.   {"ah",              &Interpreter::activateHull},
  70.   {"dh",              &Interpreter::deactivateHull},
  71.   {"cb",              &Interpreter::cutBranchWhenHit},
  72.   {"%",               &Interpreter::cutBranch},
  73.   {"texture",         &Interpreter::texture},
  74.   {"LastFunc",        NULL}
  75. };
  76.  
  77. FP* Interpreter::functable = NULL;
  78. Value Interpreter::turtleX;
  79. Value Interpreter::turtleY;
  80. Value Interpreter::turtleZ;
  81.  
  82. typedef Turtle* TurtlePtr;
  83. declareList(TurtleStack, TurtlePtr)
  84. implementList(TurtleStack, TurtlePtr)
  85.  
  86. //___________________________________________________________ Interpreter
  87.  
  88. Interpreter::Interpreter(DeviceDriver* device, Options* theOptions)
  89. : d(device), options(theOptions),
  90.   t(NULL), m(NULL), ml(NULL), currentModule(-1), saveTurtle(NULL), 
  91.   polyStack(new PolygonList(100)), turtleStack(new TurtleStack(100)),
  92.   definingMacro(FALSE), reflected(FALSE), deleteBranchWhenHit(FALSE)
  93. {
  94.  
  95.   /*
  96.    * Set up function table if not already done.
  97.    */
  98.   if (functable == NULL) {
  99.  
  100.     /*
  101.      * Add all the function names to global name space.
  102.      */
  103.     for (register int i=0; FuncTable[i].function != NULL; i++) 
  104.       FuncTable[i].index = Name::addname(FuncTable[i].name);
  105.  
  106.     functable = new FP[Name::namesCount()];
  107.  
  108.     /*
  109.      * Generate and initialize hash table for function pointers.
  110.      */
  111.     for (i=0; i<Name::namesCount(); i++)
  112.       functable[i] = NULL;
  113.     for (i=0; FuncTable[i].function != NULL; i++)
  114.       functable[FuncTable[i].index] = FuncTable[i].function;
  115.   }
  116.  
  117.   /*
  118.    * Set up analytic tropism functions and hulls.
  119.    */
  120.   tropismX = options->tropismX; 
  121.   tropismY = options->tropismY; 
  122.   tropismZ = options->tropismZ; 
  123.   tropismFunction = 
  124.     (tropismX != NULL) || (tropismY != NULL) || (tropismZ != NULL);
  125.   tropismWeight = options->weight;
  126.   weightFunction = (tropismWeight != NULL);
  127.   h = options->hulls;
  128. }
  129.  
  130. Interpreter::~Interpreter()
  131. {
  132.   delete polyStack;
  133.   delete turtleStack;
  134. }
  135.  
  136. /*
  137.  * Interpret the module string modules using the given dive driver.
  138.  */
  139.  
  140. void Interpreter::interpret(ModuleList* modules)
  141. {
  142.   t = new Turtle; 
  143.   ml = modules;
  144.  
  145.   /*
  146.    * Start interpretation of module string ml.
  147.    */
  148.   if (!options->quiet)
  149.     cerr << "Start of Interpretation ...\n\n";
  150.  
  151.   d->begin();
  152.  
  153.   /*
  154.    * For each module lookup corresponding interpreter function, call it
  155.    * if not NULL.
  156.    */
  157.   for (currentModule = 0; currentModule < ml->count(); currentModule++) {
  158.     m = ml->item(currentModule);
  159.     if (functable[ml->item(currentModule)->name().index()] != NULL) {
  160.       FP currentFunc = functable[ml->item(currentModule)->name().index()];
  161.       (this->*currentFunc)();
  162.     }
  163.       
  164.     if (options->deleteModules)
  165.       delete ml->item(currentModule);
  166.  
  167.     /*
  168.      * If we hit any hull primitive and deleteBranchWhenHit option is
  169.      * set, ignore all modules up to the next end branch command ("]").
  170.      * Note that we have to skip all the subbranches also.
  171.      */
  172.     if (deleteBranchWhenHit && reflected) {
  173.       reflected = FALSE; // reset
  174.       cutBranch();
  175.     }
  176.   }
  177.  
  178.   flush();
  179.  
  180.   /*
  181.    * Visualize the defined hulls.
  182.    */
  183.   if (options->showHulls) {
  184.     PolygonList* polys;
  185.  
  186.     Color hullColor("HullColor");
  187.     d->color(hullColor);
  188.     for (HullSymtab_Iterator hullItr(*h); hullItr.more(); hullItr.next()) {
  189.       polys = hullItr.cur_value()->convertToPolygonList(t->bbox());
  190.       for (register long i=0; i<polys->count(); i++)
  191.     d->polygon(polys->item(i));
  192.       delete polys;
  193.     } 
  194.   }
  195.  
  196.   if (options->verbose) {
  197.     cerr << "BoundingBox: " << t->bbox() << "\n\n";
  198.     cerr << "intersection tests: " 
  199.      << GeoObject::getIntersectionTests() <<"\n"
  200.          << "intersection hits:  " 
  201.      << GeoObject::getIntersections() << "\n\n";
  202.   }
  203.  
  204.   d->end(t->bbox());
  205.  
  206.   delete t;
  207. }
  208.  
  209. //___________________________________________________________ interpreter functions
  210.  
  211. /*
  212.  * Flush checks if there is a segment in the pipe which has't been draw yet
  213.  * (lastWidth > 0) and draws it in that case.
  214.  */
  215.  
  216. void Interpreter::flush()
  217. {
  218.   /*
  219.    * A segment left in the pipe?
  220.    */
  221.   if (t->getLastWidth() > 0) {
  222.     if (tropismFunction || weightFunction)
  223.       computeTropism();
  224.  
  225.     d->color(t->getLastColor());
  226.     d->texture(t->getLastTexture());
  227.  
  228.     if (equal(t->getLastWidth(), t->getWidth()))
  229.       d->cylinder(t->lastPos(), t->pos(), t->getWidth());
  230.     else if (!options->coneSpheres)
  231.       d->cone(t->lastPos(), t->getLastWidth(), t->pos(), t->getWidth());
  232.     else
  233.       createConeBetweenSpheres(t->lastPos(), t->getLastWidth(), 
  234.                    t->pos(), t->getWidth());      
  235.     if (options->coneSpheres)
  236.       d->sphere(t->pos(), t->getWidth());
  237.   }
  238.   t->setLastWidth(-1); // no segments left in the pipe
  239. }
  240.  
  241. /*
  242.  * Go forward and draw a line.
  243.  * lastWidth < 0: no move has been previously done
  244.  */
  245.  
  246. void Interpreter::forward()
  247. { 
  248.   real step;
  249.  
  250.   /*
  251.    * Is there an argument for the move?
  252.    */
  253.   if (m->argCount() <= 0 || !m->arg(0)->toReal(step)) 
  254.     step = options->defaultForward;
  255.  
  256.   /*
  257.    * Do we really have to move?
  258.    */
  259.   if (equal(step, 0)) {
  260.     Error(ERR_ADVISE, "Interpreter::forward with argument 0");
  261.     return;
  262.   }
  263.  
  264.   /*
  265.    * Recompute tropism and weight functions if any present.
  266.    */
  267.   if (tropismFunction || weightFunction)
  268.     computeTropism();
  269.  
  270.   if (t->getLastWidth() > 0) {
  271.     d->color(t->getLastColor());
  272.     d->texture(t->getLastTexture());
  273.   }
  274.  
  275.   real lastWidth    = t->getLastWidth();
  276.   real currentWidth = t->getWidth();
  277.   Vector lastPos    = t->lastPos();
  278.   Vector currentPos = t->pos();
  279.   reflected = t->forward(step);
  280.   Vector newPos     = t->pos();
  281.  
  282.   /*
  283.    * Regular line segment or cone spheres?
  284.    */
  285.   if (lastWidth > 0) {
  286.     if (equal(lastWidth, currentWidth))
  287.       d->cylinder(lastPos, currentPos, lastWidth);
  288.     else if (!options->coneSpheres)
  289.       d->cone(lastPos, lastWidth, currentPos, currentWidth);    
  290.     else 
  291.       createConeBetweenSpheres(lastPos, lastWidth, currentPos, currentWidth);
  292.     
  293.    /*
  294.     * Add sphere when there's an angle between the segments.
  295.     */
  296.     if (options->coneSpheres && !((lastPos-currentPos)*(currentPos-newPos)).zero())
  297.       d->sphere(currentPos, currentWidth);
  298.   }
  299. }
  300.  
  301. /*
  302.  * Go forward without drawing a line.
  303.  */
  304.  
  305. void Interpreter::go()
  306. { 
  307.   real step;
  308.  
  309.   flush();
  310.   if (tropismFunction || weightFunction)
  311.     computeTropism();
  312.  
  313.   if (m->argCount()>0 && m->arg(0)->toReal(step))
  314.     reflected = t->forward(step);
  315.   else
  316.     reflected = t->forward(options->defaultForward);
  317.  
  318.   /*
  319.    * There's no segment in the pipe left.
  320.    */
  321.   t->setLastWidth(-1);
  322. }
  323.  
  324. /*
  325.  * Set line width.
  326.  */
  327.  
  328. void Interpreter::width()
  329. {
  330.   real width;
  331.   if (m->argCount()>0 && m->arg(0)->toReal(width) && width>0) 
  332.     t->setWidth(width);
  333. }
  334.  
  335. /*
  336.  * Pitch turtle in positive direction.
  337.  */
  338.  
  339. void Interpreter::pitch()
  340. { 
  341.   real a;
  342.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  343.     t->pitch(dtor(a));
  344.   else
  345.     t->pitch(options->defaultPitch);
  346. }
  347.  
  348. /*
  349.  * Pitch turtle in negative direction.
  350.  */
  351.  
  352. void Interpreter::pitch_negativ()
  353. { 
  354.   real a;
  355.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  356.     t->pitch(-dtor(a));
  357.   else
  358.     t->pitch(-options->defaultPitch);
  359. }
  360.  
  361. /*
  362.  * Turn turtle in positive direction.
  363.  */
  364.  
  365. void Interpreter::turn()
  366. { 
  367.   real a;
  368.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  369.     t->turn(dtor(a));
  370.   else
  371.     t->turn(options->defaultTurn);
  372. }
  373.  
  374. /*
  375.  * Turn turtle in negative direction.
  376.  */
  377.  
  378. void Interpreter::turn_negativ()
  379. { 
  380.   real a;
  381.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  382.     t->turn(-dtor(a));
  383.   else
  384.     t->turn(-options->defaultTurn);
  385. }
  386.  
  387. /*
  388.  * Roll turtle in positive direction.
  389.  */
  390.  
  391. void Interpreter::roll()
  392. { 
  393.   real a;
  394.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  395.     t->roll(dtor(a));
  396.   else
  397.     t->roll(options->defaultRoll);
  398. }
  399.  
  400. /*
  401.  * Roll turtle in negative direction.
  402.  */
  403.  
  404. void Interpreter::roll_negativ()
  405. { 
  406.   real a;
  407.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  408.     t->roll(-dtor(a));
  409.   else
  410.     t->roll(-options->defaultRoll);
  411. }
  412.  
  413. /*
  414.  * Align turtle vertical.
  415.  */
  416.  
  417. void Interpreter::rotate_vertical()
  418. {
  419.   t->rotate_vertical();
  420. }
  421.  
  422. /*
  423.  * Reverse heading of the turtle.
  424.  */
  425.  
  426. void Interpreter::reverse()
  427. {
  428.   t->reverse();
  429. }
  430.  
  431. /*
  432.  * Save current turtle state on the stack.
  433.  */
  434.  
  435. void Interpreter::push()
  436. {
  437.   turtleStack->prepend(t);
  438.   t = new Turtle(*t);
  439.   t->setLastWidth(-1);
  440. }
  441.  
  442. /*
  443.  * Restore turtle state from stack.
  444.  */
  445.  
  446. void Interpreter::pop()
  447. {
  448.   flush();
  449.  
  450.   if (turtleStack->count() > 0) {
  451.     turtleStack->item(0)->expandBBoxBy(t->bbox());
  452.     delete t;
  453.     t = turtleStack->item(0);
  454.     turtleStack->remove(0);
  455.   }
  456.   else 
  457.     Error(ERR_WARN, "Interpreter::pop stack is empty");
  458. }
  459.  
  460. /*
  461.  * Start a new polygon.
  462.  */
  463.  
  464. void Interpreter::startPolygon()
  465. {
  466.   polyStack->prepend(new Polygon);
  467. }
  468.  
  469. /*
  470.  * Add vertex to current polygon.
  471.  */
  472.  
  473. void Interpreter::saveVertex()
  474. {
  475.   if (polyStack->count() > 0)
  476.     polyStack->item(0)->addVertex(t->pos());
  477.   else
  478.     Error(ERR_WARN, "Interpreter::saveVertex polygon stack is empty");
  479. }
  480.  
  481. /*
  482.  * End of polygon definition.
  483.  */
  484.  
  485. void Interpreter::endPolygon()
  486. {
  487.   if (polyStack->count() <= 0) {
  488.     Error(ERR_WARN, "Interpreter::endPolygon polygon stack is empty");
  489.     return;
  490.   }
  491.  
  492.   Polygon* p = polyStack->item(0);
  493.  
  494.   if (p->numVertices() <= 0) {
  495.     Error(ERR_WARN, "Interpreter::endPolygon no vertex in polygon");
  496.     delete p;
  497.     polyStack->remove(0);
  498.     return;
  499.   }
  500.   
  501.   /*
  502.    * Start and endpoint should not be the same.
  503.    */
  504.   if (p->numVertices()>1 && p->vertex(0) == p->vertex(p->numVertices()-1))
  505.     p->removeVertex(p->numVertices()-1);
  506.  
  507.   /* 
  508.    * Set color and texture.
  509.    */
  510.   d->color(t->getColor());
  511.   d->texture(t->getTexture());
  512.  
  513.   d->polygon(p);
  514.  
  515.   polyStack->remove(0);
  516. }
  517.  
  518. /*
  519.  * Set tropism vector.
  520.  */
  521.  
  522. void Interpreter::tropism()
  523. {
  524.   real x, y, z, w;
  525.   if (m->argCount() >= 3  &&  
  526.       m->arg(0)->toReal(x) && m->arg(1)->toReal(y) && m->arg(2)->toReal(z)) {
  527.     t->setTropism(x,y,z);
  528.  
  529.     if (m->argCount() >= 4 && m->arg(3)->toReal(w))
  530.       t->setWeight(w);
  531.   }
  532. }
  533.  
  534. /*
  535.  * Set weight for tropism calculations.
  536.  */
  537.  
  538. void Interpreter::weight()
  539. {
  540.   real w;
  541.   if (m->argCount()>0 && m->arg(0)->toReal(w)) 
  542.     t->setWeight(w);
  543. }
  544.  
  545. /*
  546.  * Set color.
  547.  */
  548.  
  549. void Interpreter::color()
  550. {
  551.   if (m->argCount()>0) {
  552.     Color c(m->arg(0)->toString());
  553.     t->setColor(c);
  554.   }
  555. }
  556.  
  557. /* 
  558.  * Start macro definition.
  559.  */
  560.  
  561. void Interpreter::beginMacro()
  562. {
  563.   if (definingMacro) 
  564.     Error(ERR_PANIC, "Interpreter::beginMacro nested macro definition");
  565.   
  566.   if (m->argCount() <= 0) 
  567.     Error(ERR_PANIC, "Interpreter::beginMacro macro definition without a name");
  568.  
  569.   rcString macroName(m->arg(0)->toString());
  570.  
  571.   if (!d->addMacroName(macroName))
  572.     Error(ERR_PANIC, "Interpreter::beginMacro macro \"" 
  573.                      + macroName + "\" already defined");
  574.   
  575.   saveTurtle = t; 
  576.   t = new Turtle; 
  577.   definingMacro = TRUE;
  578.   d->beginMacro(macroName);
  579. }
  580.  
  581. /*
  582.  * End of macro definition.
  583.  */
  584.  
  585. void Interpreter::endMacro()
  586. {
  587.   if (definingMacro == FALSE) {
  588.     Error(ERR_WARN, "Interpreter::endMacro missing begin macro");
  589.     return;
  590.   }
  591.  
  592.   flush();
  593.   d->endMacro();
  594.   delete t;
  595.   t = saveTurtle; saveTurtle = NULL;
  596.   definingMacro = FALSE;
  597. }
  598.  
  599. /*
  600.  * Execute a already defined macro.
  601.  */
  602.  
  603. void Interpreter::executeMacro()
  604. {
  605.   if (m->argCount() <= 0) {
  606.     Error(ERR_WARN, "Interpreter::executeMacro macro without a name");
  607.     return;
  608.   }
  609.  
  610.   TransMatrix tmat;
  611.   real scale;
  612.  
  613.   tmat(0,0) = t->vecU()[0]; tmat(0,1) = t->vecU()[1]; tmat(0,2) = t->vecU()[2]; 
  614.   tmat(1,0) = t->vecL()[0]; tmat(1,1) = t->vecL()[1]; tmat(1,2) = t->vecL()[2]; 
  615.   tmat(2,0) = t->vecH()[0]; tmat(2,1) = t->vecH()[1]; tmat(2,2) = t->vecH()[2]; 
  616.  
  617.   if (m->argCount()>1 && m->arg(1)->toReal(scale) && !equal(scale, 1))
  618.     tmat.scale(scale, scale, scale);
  619.   tmat.translate(t->pos());
  620.  
  621.   d->executeMacro(m->arg(0)->toString(), tmat);
  622. }
  623.  
  624. /*
  625.  * Include a predefined object.
  626.  */
  627.  
  628. void Interpreter::libraryObject()
  629. {
  630.   if (m->argCount() <= 0) {
  631.     Error(ERR_WARN, "Interpreter::libraryObject object without a name");
  632.     return;
  633.   }
  634.  
  635.   TransMatrix tmat;
  636.   real scale;
  637.  
  638.   rcString libName(m->arg(0)->toString());
  639.  
  640.   d->addLibraryObjectName(libName);
  641.  
  642.   tmat(0,0) = t->vecU()[0]; tmat(0,1) = t->vecU()[1]; tmat(0,2) = t->vecU()[2]; 
  643.   tmat(1,0) = t->vecL()[0]; tmat(1,1) = t->vecL()[1]; tmat(1,2) = t->vecL()[2]; 
  644.   tmat(2,0) = t->vecH()[0]; tmat(2,1) = t->vecH()[1]; tmat(2,2) = t->vecH()[2]; 
  645.  
  646.   if (m->argCount()>1 && m->arg(1)->toReal(scale) && !equal(scale, 1))
  647.     tmat.scale(scale, scale, scale);
  648.   tmat.translate(t->pos());
  649.  
  650.   d->libraryObject(libName, tmat);
  651. }
  652.  
  653. /*
  654.  * Generate sphere at turtle position with given radius.
  655.  */
  656.  
  657. void Interpreter::sphere()
  658. {
  659.   real r;
  660.  
  661.   /* 
  662.    * Set color and texture.
  663.    */
  664.   d->color(t->getColor());
  665.   d->texture(t->getTexture());
  666.  
  667.   if (m->argCount()>0 && m->arg(0)->toReal(r)) 
  668.     d->sphere(t->pos(), r);
  669.   else
  670.     d->sphere(t->pos(), 1);
  671. }
  672.  
  673. /*
  674.  * Generate triangle with given vertices.
  675.  */
  676.  
  677. void Interpreter::triangle()
  678. {
  679.   if (m->argCount() < 9)
  680.     return;
  681.  
  682.   real coords[9];
  683.   for (register int i=0; i<9; i++)
  684.     if (!m->arg(i)->toReal(coords[i]))
  685.       return;
  686.  
  687.   Vector p1(coords[0], coords[1], coords[2]); 
  688.   Vector p2(coords[3], coords[4], coords[5]); 
  689.   Vector p3(coords[6], coords[7], coords[8]); 
  690.  
  691.   BoundingBox tmpBBox;
  692.   tmpBBox.expand(p1);
  693.   tmpBBox.expand(p2);
  694.   tmpBBox.expand(p3);
  695.   t->expandBBoxBy(tmpBBox);
  696.  
  697.   /* 
  698.    * Set color and texture.
  699.    */
  700.   d->color(t->getColor());
  701.   d->texture(t->getTexture());
  702.  
  703.   d->polygon(new Polygon(p1, p2, p3));
  704. }
  705.  
  706. /*
  707.  * Generate polygon with given vertices.
  708.  */
  709.  
  710. void Interpreter::polygon()
  711. {
  712.   if (m->argCount() < 9)
  713.     return;
  714.  
  715.   real x, y, z;
  716.   Polygon* p = new Polygon(3);
  717.   BoundingBox tmpBBox;
  718.  
  719.   for (register int i=0; i<m->argCount()-2; i+=3) {
  720.     if (m->arg(i)->toReal(x)   && 
  721.     m->arg(i+1)->toReal(y) && 
  722.     m->arg(i+2)->toReal(z)) 
  723.       {
  724.     p->addVertex(Vector(x,y,z));
  725.     tmpBBox.expand(Vector(x,y,z));
  726.       }
  727.   }
  728.  
  729.   if (p->numVertices() > 2) {
  730.  
  731.     /* 
  732.      * Set color and texture.
  733.      */
  734.     d->color(t->getColor());
  735.     d->texture(t->getTexture());
  736.  
  737.     d->polygon(p);
  738.     t->expandBBoxBy(tmpBBox);
  739.   }
  740.   else
  741.     delete p;
  742. }
  743.  
  744. /*
  745.  * Activate a hull. Turtle will move with respect to the primitives
  746.  * of the hull.
  747.  */
  748.  
  749. void Interpreter::activateHull()
  750. {
  751.   if (m->argCount()<=0) {
  752.     Error(ERR_WARN, "Interpreter::activateHull no hull name");
  753.     return;
  754.   }
  755.  
  756.   rcString hullName(m->arg(0)->toString());
  757.  
  758.   Hull* hull;
  759.   if (!h->lookup(hullName, hull)) {
  760.     Error(ERR_WARN, "Interpreter::activateHull unknown hull " + hullName);
  761.     return;
  762.   }
  763.   real reflectanceFactor = 1;
  764.   if (m->argCount()>1)
  765.     m->arg(1)->toReal(reflectanceFactor);
  766.   
  767.   t->setHull(hull, reflectanceFactor);
  768. }
  769.  
  770. void Interpreter::deactivateHull()
  771. {
  772.   t->unsetHull();
  773. }
  774.  
  775. /*
  776.  * Set/Unset of delete branch when conflict with current hull.
  777.  */
  778.  
  779. void Interpreter::cutBranchWhenHit()
  780. {
  781.   real flag = TRUE;
  782.   if (m->argCount() > 0)
  783.     m->arg(0)->toReal(flag);
  784.     
  785.   if ((int)flag) {
  786.     deleteBranchWhenHit = TRUE;
  787.     t->setStopOnHit();
  788.   }
  789.   else {
  790.     deleteBranchWhenHit = FALSE;
  791.     t->unsetStopOnHit();
  792.   }
  793. }
  794.  
  795. /*
  796.  * Ignore all the modules until we find a end branch symbol (ignore
  797.  * subbranches also).
  798.  */
  799.  
  800. void Interpreter::cutBranch()
  801. {
  802.   static Name startBranch(startBranchSymbol);
  803.   static Name endBranch(endBranchSymbol);
  804.   int nested = 0;
  805.  
  806.   /*
  807.    * Ignore all modules up to the next end branch command ("]").
  808.    * Note that we have to skip all the subbranches also.
  809.    */
  810.   while (++currentModule < ml->count()) {
  811.     if (ml->item(currentModule)->name() == startBranch)
  812.       nested++;
  813.     else if (ml->item(currentModule)->name() == endBranch) {
  814.       if (nested-- == 0) {
  815.     currentModule--; 
  816.     break;
  817.       }
  818.     }
  819.     if (options->deleteModules)
  820.       delete ml->item(currentModule);
  821.   }
  822. }
  823.  
  824. /*
  825.  * Define texture for the following primitives.
  826.  */
  827. void Interpreter::texture()
  828. {
  829.   if (m->argCount()>0) {
  830.     rcString theTexture(m->arg(0)->toString());
  831.     t->setTexture(theTexture);
  832.   }
  833.   else
  834.     t->setTexture(""); // disable textures
  835. }
  836.  
  837. /*
  838.  * Generate a cone between two given spheres. 
  839.  */
  840.  
  841. void Interpreter::createConeBetweenSpheres(const Vector& p1, real r1, 
  842.                             const Vector& p2, real r2)
  843. {
  844.   real a = r1-r2;
  845.   real r = r1;
  846.   real c = p1.distance(p2);
  847.   int secondIsLarger = FALSE;
  848.  
  849.   if (c<r1 || c<r2) {
  850.     Error(ERR_ADVISE, rcString("Interpreter::createConeBetweenSpheres\n") + 
  851.                       "\tdistance between spheres is too small -> can't create cone\n");
  852.     return;
  853.   }
  854.     
  855.   if (a < 0) {
  856.     r = r2;
  857.     a = -a;
  858.     secondIsLarger = TRUE;
  859.   }
  860.   
  861.   real p  = a*a/c;
  862.   real ps = p*r/a;
  863.  
  864.   real h  = sqrt(p*(c-p));
  865.   real hs = h*r/a;
  866.  
  867.   Vector dir = p2 - p1;
  868.  
  869.   if (secondIsLarger)
  870.     d->cone(p1-dir*((ps-p)/c), hs-h, p2-dir*(ps/c), hs);
  871.   else
  872.     d->cone(p1+dir*(ps/c), hs, p2+dir*((ps-p)/c), hs-h);
  873. }
  874.  
  875. /*
  876.  * If tropism vector depends on turtle position, we recompute the
  877.  * tropism vector after each move.
  878.  */
  879.  
  880. void Interpreter::computeTropism()
  881. {
  882.   turtleX = t->pos()[0];
  883.   turtleY = t->pos()[1];
  884.   turtleZ = t->pos()[2];
  885.  
  886.   if (tropismFunction)
  887.     t->setTropism(tropismX->evaluate(),
  888.           tropismY->evaluate(),
  889.           tropismZ->evaluate());  
  890.  
  891.   if (weightFunction)
  892.     t->setWeight(tropismWeight->evaluate());
  893. }
  894.